
import bpy
import os
import random

from 节点.全局控制.Node.节点和插座基类 import bl_节点基类
from 节点.全局控制.Node.插座 import bl_插座基类

import Core.bl_UI配色 as UI配色

import engine.initLIB.load_dll as engineLib
import ctypes




import Core.File.文件操作 as 文件操作

from 全局控制.Node.节点数据类型 import bl_集合数据类型






class C_NODE_button_创建新图像(bpy.types.Operator):
	bl_idname = 'node.create_new_image'
	bl_label = '创建新图像'
	bl_options = {'REGISTER', 'UNDO'}

	m_TreeName = bpy.props.StringProperty()
	m_NodeName = bpy.props.StringProperty()

	def execute(self, context):
		t = bpy.data.textures.new('new image', 'IMAGE')
		node = bpy.data.node_groups[self.m_TreeName].nodes[self.m_NodeName]
		node.outputs['bl图像'].f_setData(t)
		#bpy.ops.node.add_node(type='C_Node_图像', use_transform=True)
		return {'FINISHED'}






class C_Node_图像集(bl_节点基类.C_Node_基类):
	bl_dname = 'bl_node_图像集'
	bl_label = '图像集'
	bl_icon = 'FILE_IMAGE'

	#m_Value = bpy.props.CollectionProperty(type=bl_集合数据类型.C_纹理数据)
	m_文件路径 = bpy.props.StringProperty(subtype='FILE_PATH')
	m_重新加载 = bpy.props.BoolProperty()
	m_构建数量 = bpy.props.IntProperty()
	m_拷贝到内部 = bpy.props.BoolProperty(default=True)
	m_图像序列 = bpy.props.BoolProperty(default=False)
	def init(self, context):
		super(C_Node_图像集, self).f_init(context)
		self.outputs.new('C_Socket_图像', name='图像')
		self.m_构建数量 = -1 
		
	def draw_buttons(self, context, layout):
		layout.prop(self, "m_文件路径", text="文件路径")
		layout.prop(self, "m_重新加载", text="是否重新加载")
		layout.prop(self, "m_构建数量", text="构建数量")
		
	'''def update(self):
		insocket = self.inputs['_>']
		if insocket.is_linked :
			if insocket.f_getData():
				self.f_数据拷贝到输出插座中()
			else:
				self.outputs['物体'].f_clear()'''
	
	def f_update(self):
		图像集 = self.outputs['图像集']
		
		path = str(bpy.path.abspath(self.m_文件路径))
		
		当下目录文件 = list(文件操作.f_get目录下文件名(path))
		#print('当下目录文件 = ', 当下目录文件)
		images = []
		for fn in 当下目录文件:
			#print('bpy.path.abspath(self.m_文件路径) = ', path, fn)
			图像 = bpy.data.images.load(path + fn, check_existing=self.m_重新加载)
			images.append(图像)


		#数量补充
		纹理数量 = len(images)
		
		while len(images) < self.m_构建数量:
			补充数量 = min(self.m_构建数量 - 纹理数量, 纹理数量)
			randoImage = random.sample(images, 补充数量)
			images.extend(randoImage)
			纹理数量 = len(images)

		图像集.f_setData(images)
		


	
class C_NODE_MENU_图像集(bpy.types.Operator):
	bl_idname = 'node.global_node_objects_textures'
	bl_label = '图像集'
	bl_options = {'REGISTER', 'UNDO'}
	
	def execute(operator, context):
		bpy.ops.node.add_node(type='C_Node_图像集', use_transform=True)
		return {'FINISHED'}
		













class C_Node_纹理集(bl_节点基类.C_Node_基类):
	bl_dname = 'bl_node_纹理集'
	bl_label = '纹理集'
	bl_icon = 'FILE_IMAGE'

	m_文件路径 = bpy.props.StringProperty(subtype='FILE_PATH')
	def init(self, context):
		super(C_Node_纹理集, self).f_init(context)
		self.outputs.new('C_NodeSocket_纹理集', name='纹理集')

	def f_update(self, 是否向下传递=False, input插座=None):
		纹理集 = self.outputs['纹理集']
		dirs = os.listdir(bpy.path.abspath(self.m_文件路径))
		当下目录文件 = 文件操作.f_get目录下文件名(str(dirs))
		images = []

class C_NODE_MENU_纹理集(bpy.types.Operator):
	bl_idname = 'node.global_node_objects_images'
	bl_label = '纹理集'
	bl_options = {'REGISTER', 'UNDO'}
	
	def execute(operator, context):
		bpy.ops.node.add_node(type='C_Node_纹理集', use_transform=True)
		return {'FINISHED'}














E_图像属性枚举 = [
	("TYPE_size", "size", "", 0),
	("TYPE_depth", "depth", "", 1),
	("TYPE_filepath", "filepath", "", 2),
	("TYPE_source", "source", "", 3),
	("TYPE_pixels", "pixels", "", 4),
]


class C_Node_取纹理属性(bl_节点基类.C_SN_基类):
	bl_dname = 'bl_node_取纹理属性'
	bl_label = '取纹理属性'
	
	m_图像属性类型 = bpy.props.EnumProperty(items=E_图像属性枚举)
	def init(self, context):
		super(C_Node_取纹理属性, self).f_init(context)
		self.bl_icon = 'FILE_IMAGE'
		self.inputs.new('C_NodeSocket_纹理集', name='纹理集')
		self.outputs.new('C_NodeSocket_通用', name='属性')

	def draw_buttons(self, context, layout):
		layout.prop(self, "m_图像属性类型", text="属性类型")

	def f_update(self, 是否向下传递=False, input插座=None):
		纹理集 = self.inputs['纹理集'].f_getData()

		属性s = []
		for t in 纹理集:
			if self.m_图像属性类型 == 'TYPE_size':
				属性s.append(list(t.size))
			elif self.m_图像属性类型 == 'TYPE_depth':
				属性s.append(t.depth)
			elif self.m_图像属性类型 == 'TYPE_filepath':
				属性s.append(t.filepath)
			elif self.m_图像属性类型 == 'TYPE_source':
				属性s.append(t.source)
			elif self.m_图像属性类型 == 'TYPE_pixels':
				属性s.append(t.pixels)
		#print('属性s = ', 属性s)
		#pdb.set_trace()
		self.outputs['属性'].f_setData(属性s)
		super(C_Node_取纹理属性, self).f_update(是否向下传递, input插座)


class C_NODE_MENU_取纹理属性(bpy.types.Operator):
	bl_idname = 'node.global_node_get_texture_attr'
	bl_label = '取纹理属性'
	bl_options = {'REGISTER', 'UNDO'}
	def execute(operator, context):
		bpy.ops.node.add_node(type='C_Node_取纹理属性', use_transform=True)
		return {'FINISHED'}


























class C_Node_图像(bl_节点基类.C_Node_基类):
	bl_dname = 'bl_node_图像'
	bl_label = '图像'
	bl_icon = 'FILE_IMAGE'

	#m_Value = bpy.props.PointerProperty(type=bpy.types.Texture)
	#m_文件路径 = bpy.props.StringProperty(subtype='FILE_PATH')
	m_拷贝到内部 = bpy.props.BoolProperty(default=True)
	#m_图像序列 = bpy.props.BoolProperty(default=False)
	#m_重新加载 = bpy.props.BoolProperty()
	def init(self, context):
		super(C_Node_图像, self).f_init(context)
		self.inputs.new('C_Socket_I32', name='序列偏移')

		self.outputs.new('C_Socket_图像', name='bl图像')
		self.outputs.new('C_Socket_纹理', name='bl纹理')
		self.outputs.new('C_Socket_iVec2', name='分辨率')
		self.outputs.new('C_Socket_iVec2', name='帧区间')
		self.outputs.new('C_Socket_Vec4_Array1D', name='像素')
		
		self.f_toCPP()

	def f_toCPP(self):
		engineLib.flexCAPI.f_创建图像节点(ctypes.c_wchar_p(self.id_data.name), ctypes.c_wchar_p(self.name), self.f_getPyObject());


		
	def draw_buttons(self, context, layout):
		layout.prop(self, "m_拷贝到内部", text="拷贝到内部")
		
		图像 = self.outputs['bl图像'].f_getData()
		if 图像 :
			layout.template_image(图像, "image", 图像.image_user)
			
		else:
			item = layout.operator('node.create_new_image', icon='ADD')
			item.m_TreeName = self.id_data.name
			item.m_NodeName = self.name
			

		
	def f_update(self):
		图像 = self.outputs['bl图像'].f_getData()
		if 图像 :
			data = [list("pixel"), tuple(图像.image.size), (图像.image_user.frame_duration, 图像.image_user.frame_start), list(图像.image.pixels)]
			engineLib.flexCAPI.f_node_传入BL数据(ctypes.c_wchar_p(self.id_data.name), ctypes.c_wchar_p(self.name), ctypes.py_object(data));

		



class C_NODE_MENU_图像(bpy.types.Operator):
	bl_idname = 'node.create_node_texture'
	bl_label = '图像'
	bl_options = {'REGISTER', 'UNDO'}
	def execute(self, context):
		bpy.ops.node.add_node(type='C_Node_图像', use_transform=True)
		return {'FINISHED'}
		









classes = (
	C_NODE_button_创建新图像,

	C_Node_图像,
	C_NODE_MENU_图像,
	
)

def register():
	for c in classes:
		bpy.utils.register_class(c)
		
def unregister():
	for c in classes:
		bpy.utils.unregister_class(c)




